Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@ci/unit_tests/test_coronaryArtery_ct_segmentation.py`:
- Around line 55-56: The synthetic test data is invalid: fix creation of
test_image and test_label by sampling CT-intensity-range into a dtype that can
hold Hounsfield units and producing true binary labels; specifically change the
array dtype for test_image (variable name test_image) from np.int8 to np.int16
(so values sampled from low=-1024, high=1000 are represented correctly) and
change the randint call for test_label (variable name test_label) to use high=2
so it can generate 0 and 1 labels rather than all zeros.
- Around line 65-77: The test calls check_workflow(inferrer,
check_properties=True) which triggers ConfigWorkflow ->
CoroSegmentatorPipeline.run and performs heavy external work
(monai.apps.utils.download_url and NNUnetPredictor.run spawning
nnUNetv2_predict); to fix, patch/mock those external operations in the test so
only wiring is validated: either stub CoroSegmentatorPipeline.run to a no-op or
mock monai.apps.utils.download_url and subprocess.run (or the method
NNUnetPredictor.run) to return successfully without downloading or invoking
nnUNetv2_predict; ensure your mocks target the exact symbols ConfigWorkflow
(test instantiation), CoroSegmentatorPipeline.run, download_url,
NNUnetPredictor.run, and the subprocess invocation name nnUNetv2_predict so the
test runs in CI without performing network or subprocess work.

In `@models/CoronSegmentator/configs/inference.json`:
- Line 8: The config currently builds "data" eagerly via "data":
"$list(sorted(glob.glob(`@dataset_dir` + '/*.nii.gz')))" and then uses `@data`[0] in
inferer.input_params.inputFile which raises IndexError when dataset_dir is
empty; change this by deferring or guarding the lookup: remove the eager
`@data`[0] dependency and instead resolve the input file at runtime inside
CoronSegmentatorPipeline.run() (or add a safe helper that returns a
sentinel/default or raises a clear, documented error if no .nii.gz files are
found), update inferer.input_params.inputFile to reference that runtime-resolved
value (or a safe placeholder), and add prominent documentation in the config
comment that dataset_dir must be overridden or contain NIfTI files so
ConfigWorkflow.check_workflow and monai.bundle run do not crash at construction
time.

In `@models/CoronSegmentator/configs/metadata.json`:
- Around line 38-50: The metadata.json currently declares format: "hounsfield"
but sets value_range: [0, 1], which is inconsistent; either set "value_range" to
a representative HU window (e.g., the clipping window your pipeline uses such as
[-1024, 3071] or a narrower window like [-125, 275] depending on preprocessing)
while keeping format: "hounsfield", or change format to reflect pre-normalized
data (e.g., "normalized" or "float32_normalized") and update README to document
the min-max or z-score normalization; update the "value_range" field and README
accordingly and ensure any references to network_data_format elsewhere in the
repo are consistent with the chosen option.

In `@models/CoronSegmentator/docs/README.md`:
- Around line 13-15: The README's opening paragraph, Tags, and "processed by"
steps still describe dual whole-heart + coronary segmentation, but the bundle is
coronary-only (see metadata.json task: "Coronary artery ct segmentation");
update models/CoronSegmentator/docs/README.md to remove references to MONAI
Auto3DSeg and whole-heart segmentation, revise the opening paragraph to state
coronary artery–only scope, adjust the Tags list, and change the "processed by"
steps (lines referencing MONAI/Auto3DSeg) to only list the custom nnU-Net
coronary segmentation and subsequent STL→USD conversion for 3D visualization.
- Around line 45-46: The ImageCAS dataset URL in
models/CoronSegmentator/docs/README.md contains two stray single quotes at the
end ("...-on-CT.git''") which break the link; remove the extra quote characters
so the URL ends with ".git" (update the ImageCAS dataset URL line in the README
to
"https://github.com/XiaoweiXu/ImageCAS-A-Large-Scale-Dataset-and-Benchmark-for-Coronary-Artery-Segmentation-based-on-CT.git").
- Around line 41-43: The README's example `monai.bundle run` invocation is
missing required parameters, causing the `data` list to be empty and `@data[0]`
to IndexError; update the example to pass `--meta_file`, `--logging_file`, and a
non-empty `--dataset_dir` that matches the glob used in `configs/inference.json`
(ensure `dataset_dir` points to a folder containing `.nii.gz` files), e.g.
include flags for `--meta_file configs/metadata.json --logging_file
configs/logging.conf --dataset_dir /path/to/dataset`; confirm
`configs/inference.json`'s `"dataset_dir"` is not left as an empty string or
document overriding it via the CLI.

In `@models/CoronSegmentator/large_file.yml`:
- Line 6: The YAML field hash_type is defined but never passed into the
downloader; update CoroSegmentatorPipeline.run to read hash_type from each file
entry (e.g. file_info.get("hash_type", "md5")) and pass it into the download
call as download_url(url, filepath=..., hash_val=expected_hash,
hash_type=hash_type) so the declared algorithm is honored (alternatively remove
the unused YAML field if you prefer); locate this change around the run method
in CoroSegmentatorPipeline and the call site that currently supplies only
path/url/hash_val.
- Line 4: The model bundle in models/CoronSegmentator/large_file.yml uses a
Google Drive URL under the url key which is fragile for CI; upload the weights
to a stable direct-download host (e.g., MONAI-extra-test-data GitHub release or
another CDN), replace the url value with the new direct-download link, recompute
and update the corresponding hash_val in the same YAML entry to match the
uploaded file, and apply the same replacement for the other affected bundle
referenced as "9-9" so all references use stable hosts instead of Google Drive.

In
`@models/CoronSegmentator/scripts/coronaryArtery_segmentation/coronaryArtery_seg.py`:
- Around line 437-441: The log messages use backslash-continued f-strings which
preserve the indentation and produce unwanted spaces; locate the except blocks
catching subprocess.CalledProcessError (the logger.error calls that reference
self.input_path and e.returncode) and replace the backslash-continued f-strings
with either a single-line f-string or implicit string concatenation (e.g., f"...
segmentation inference failed with code {e.returncode}") so the message has no
embedded indentation; apply the same fix to the other two occurrences that use
logger.error with self.input_path and e.returncode.
- Around line 358-366: preprocessed_path is set inside the installed bundle
(script_path.parent) which can pollute/read-only install dirs; change it to live
under the temporary workspace like raw_path (use self.temp_dir.name, e.g.
self.preprocessed_path = os.path.join(self.temp_dir.name,
"nnUNet/nnUNet_preprocessed")) so nnUNet writes to a transient location; also
harden the model_weight construction (the list comprehension that calls
os.listdir on script_path.parent.parent.parent/"models") by first checking that
the models directory exists and using an empty list if not (or use
os.path.exists/isdir) before listing to avoid FileNotFoundError when the models/
dir is absent.

In `@models/CoronSegmentator/scripts/heart_digital_twin.py`:
- Line 9: Replace the leftover template placeholder in the module docstring at
the top of heart_digital_twin.py with a concise, accurate description of what
the module does (e.g., "Convert NIfTI (.nii/.nii.gz) medical image files into
USD scene files and generate associated heart digital twin metadata"), ensuring
the docstring reflects the script's purpose, inputs, outputs and any important
side effects; update the module-level docstring string literal (the first
triple-quoted string in the file) accordingly.
- Around line 92-104: The run() error handling silently returns False and
performs fragile cleanup; update the except block in heart_digital_twin.run to
both surface failures to the workflow (either re-raise the caught exception
after logging or raise a new exception so ConfigWorkflow sees the failure) and
replace the manual os.remove/os.rmdir loop with shutil.rmtree(seg_folder,
ignore_errors=False) (or ignore_errors=True if you prefer best-effort cleanup)
to correctly remove nested files/directories; ensure you import shutil and keep
the gc.collect() in the finally block.

---

Outside diff comments:
In `@models/CoronSegmentator/docs/data_license.txt`:
- Around line 25-29: The versions in
models/CoronSegmentator/docs/data_license.txt (monai 1.4.0, nnunetv2 2.5.1) are
inconsistent with the runtime metadata in configs/metadata.json (monai_version
and required_packages_version.nnunetv2); update the table in data_license.txt so
the listed package versions match the values in configs/metadata.json (adjust
the monai and nnunetv2 entries to the monai_version and
required_packages_version.nnunetv2 declared there), or if the metadata is wrong,
update configs/metadata.json instead—ensure both files reflect the same
canonical versions.

---

Nitpick comments:
In `@models/CoronSegmentator/configs/inference.json`:
- Around line 5-6: The config uses bundle_root: "." which breaks resolution when
run from other CWDs; change the config so bundle_root is not a hardcoded "." by
requiring a CLI override or resolving it relative to the config file (update the
bundle_root value and any derived fields like ckpt_dir and output_dir that
reference `@bundle_root`), and add an imports entry to insert `@bundle_root` into
sys.path so scripts.heart_digital_twin can be imported regardless of CWD; update
references in the config (bundle_root, ckpt_dir, output_dir, imports) to use the
resolved `@bundle_root` token rather than a literal ".".
- Around line 9-11: The JSON contains dead/unused keys (output_ext, device, and
empty objects dataset/evaluator/network_def) — either remove them or wire them
through: if you want the pipeline to honor device and output_ext, add them into
the same input_params object that is passed to the inferer/run so
CoronSegmentatorPipeline.__init__ (and whoever builds input_params) can consume
them (e.g., include "device" and "output_ext" in the input_params section and
ensure inferer/run forwards input_params into
CoronSegmentatorPipeline.__init__); otherwise delete output_ext and device from
the config and either remove or document the empty dataset/evaluator/network_def
entries in the README to satisfy ConfigWorkflow.check_properties. Ensure your
changes reference the config keys by name and that inferer/run and
CoronSegmentatorPipeline.__init__ are updated consistently.

In `@models/CoronSegmentator/configs/metadata.json`:
- Around line 57-76: The metadata currently mislabels the model output: change
outputs.pred.type from "usd" to "image" so the tensor kind correctly reflects a
segmentation output (leave "format": "segmentation", "num_channels",
"spatial_shape", etc. unchanged), and move any USD/export-file format details
into the README or an export step documentation rather than the metadata.json;
update the entry referenced as outputs.pred.type accordingly.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@models/CoronSegmentator/runtests.sh`:
- Line 86: The script uses unquoted variable expansions (e.g., cmdPrefix,
PY_EXE, TO_CLEAN) which can cause word-splitting/globbing; update all command
invocations to quote these expansions (for example use "${cmdPrefix}${PY_EXE}"
when invoking Python and quote "${TO_CLEAN}" in find invocations and test/remove
loops) while preserving behavior of the dryrun helper (ensure dryrun still
receives the intended full command string or change dryrun to accept an array of
args if you need to quote separately); apply this quoting pattern to the
locations that call the Python executable, the find/cleanup commands, and all
main execution blocks referenced in the review so globbing and spaces no longer
break runtime execution.
- Around line 122-124: The is_pip_installed function incorrectly uses command
substitution and unquoted $1, causing it to always succeed; change it to run the
Python check directly (invoke ${PY_EXE} -c "import sys, pkgutil; sys.exit(0 if
pkgutil.find_loader(sys.argv[1]) else 1)" "$1") and then return the command's
exit status (e.g., use return $? or use an if/then to return 0/1), ensuring the
package name argument is quoted when passed to ${PY_EXE}.
- Around line 126-183: The argument parser's case statement is missing handling
for the documented -v|--version flag, causing valid version requests to hit the
default invalid-key path; add a new case (e.g., -v|--version) inside the
while/case block that calls the existing print_usage or a new print_version
function (or echo a version variable) and then exits successfully, placing it
alongside the other flag cases before the help (-h|--help) case to ensure
correct handling without falling through to print_error_msg.

In
`@models/CoronSegmentator/scripts/cardiac_segmentation/auto3dseg_segresnet_inference.py`:
- Line 139: The loop using zip(keys, normalize_modes) can silently truncate if
the iterables differ in length; update that call to zip(keys, normalize_modes,
strict=True) in auto3dseg_segresnet_inference.py (the for key, normalize_mode
loop) so a ValueError is raised on length mismatch, preventing incorrect
normalization pairing.

In `@models/CoronSegmentator/scripts/cardiac_segmentation/cardiac_seg.py`:
- Around line 141-157: The error handler incorrectly indexes the list "futures"
with a Future object (futures[future]) causing a TypeError; instead, when you
submit tasks (where you call self._process_single_segment for each item in
self.segments), build a mapping like future_to_segment =
{executor.submit(self._process_single_segment, seg_image, segment, output_dir):
segment for segment in self.segments} and then iterate over
concurrent.futures.as_completed(future_to_segment) so you can reference the
failed segment via future_to_segment[future] in the exception block (use the
same TimeoutError and generic Exception handling but log the segment from the
mapping and cancel the future as needed).

In
`@models/CoronSegmentator/scripts/coronaryArtery_segmentation/coronaryArtery_seg.py`:
- Around line 546-559: The current try/except in the
concurrent.futures.as_completed loop is using futures[future] (invalid) and
swallows exceptions, masking failures; update the concurrent execution logic
(where executor.submit(process_file, nii_file) and futures list are created and
iterated) to map each Future back to its source file (e.g., keep a dict
future_to_file = {executor.submit(...): nii_file}) or use executor.map and pair
results with input names, then in the except blocks log the correct filename
(use future_to_file[future]) and either re-raise or record failures and exit
non-zero after the loop so post-processing failures are not hidden; ensure you
still call future.cancel() on timeouts and handle TimeoutError specifically for
future_to_file[future].

In `@models/CoronSegmentator/scripts/download.py`:
- Around line 29-30: Wrap the YAML file read in a safe try/except around the
open(DOWNLOAD_CONFIG, "r") and yaml.safe_load call in download.py to handle
missing or malformed config: catch FileNotFoundError and raise or log a clear
error mentioning DOWNLOAD_CONFIG is missing, catch yaml.YAMLError to report
parse/format issues and include the underlying error message, and ensure the
function either exits gracefully or re-raises a descriptive exception so callers
know the config failed to load.
- Around line 32-45: The loop over download_config["large_files"] assumes the
key and required fields exist; add explicit validation before iterating: check
that download_config is a dict and contains a "large_files" key whose value is a
list, and for each file_info (in the for ... in download_config["large_files"]
loop) validate that file_info is a dict and contains the required keys ("path",
"url", "hash_val") and optional "hash_type" (default to "md5" if absent); for
invalid entries either raise a clear ValueError or skip with a warning, and only
call download_url(url=..., filepath=BUNDLE_ROOT / rel_path, hash_val=...,
hash_type=...) when validations pass.

In `@models/CoronSegmentator/scripts/file_process/file_conversion.py`:
- Around line 34-37: The convert_nrrd_to_nii function lacks error handling; wrap
the sitk.ReadImage and sitk.WriteImage calls in a try/except like
convert_nii_to_nrrd and convert_nrrd_to_stl: catch Exception as e, log or
include the exception details with a descriptive message (e.g., "Failed
converting NRRD to NIfTI in convert_nrrd_to_nii"), and either re-raise or return
a failure indicator consistent with the other conversion helpers so callers get
contextual error information.
- Around line 19-21: The project is missing runtime deps used by
models/CoronSegmentator/scripts/file_process/file_conversion.py: add numpy,
SimpleITK (sitk), trimesh, and scikit-image (skimage) to requirements.txt so
imports like "import SimpleITK as sitk", "import trimesh", "from skimage.measure
import marching_cubes", and any numpy usage resolve; pin compatible versions (or
ranges) consistent with monai>=1.0.1 and CI, update requirements.txt
accordingly, and run a quick install+import smoke test to confirm resolution.

In `@models/CoronSegmentator/scripts/usd_design/environment_create.py`:
- Line 112: The color space string passed to SetColorSpace is misspelled; locate
the call to inp.GetAttr().SetColorSpace("sRBG") and change the literal to "sRGB"
so the correct color space name is used (update any identical occurrences of the
typo within the same module to maintain consistency).
- Line 126: Rename the misspelled method cereate_ground to create_ground in the
class defined in environment_create.py and update its call site that currently
invokes cereate_ground (reported around line 186) to call create_ground instead;
search for symbol "cereate_ground" and replace both the method definition and
every invocation with "create_ground" to prevent the AttributeError at runtime.

In `@models/CoronSegmentator/scripts/usd_design/shader_leather_red.py`:
- Around line 374-377: The loop that creates inputs calls
shader.CreateInput(name, type_name) and then skips setting defaults when
data["customData"]["default"] is falsy; change that conditional to check for the
presence of the "default" key and exclude only None (e.g., use if "default" in
data["customData"] and data["customData"]["default"] is not None:) so
inp.Set(...) runs for valid falsy defaults like 0, False, or "" while still
skipping absent/null defaults.

In `@models/CoronSegmentator/scripts/usd_design/usd_create.py`:
- Around line 47-49: The except block in create_usd() currently logs USD
conversion errors (logger.error(f"USD creation failed: {str(e)}")) but swallows
them, allowing callers to proceed; modify the except handler in create_usd() to
re-raise the caught exception after logging (e.g., raise) so upstream callers
see the failure and the pipeline can stop or handle it appropriately while
preserving the logged message.

In `@models/CoronSegmentator/scripts/usd_design/usd_mesh_creator.py`:
- Around line 128-131: The loop over input_files and meshes uses
zip(self.input_files, meshes) which can silently truncate when lengths differ;
change it to use zip(self.input_files, meshes, strict=True) so a ValueError is
raised if sizes mismatch. Update the iteration where get_paths(...) and
create_usd_mesh(...) are called (the block referencing self.input_files, meshes,
get_paths, create_usd_mesh, and appending to mesh_paths) to use zip(...,
strict=True) and handle or let the raised exception propagate appropriately.

In `@models/CoronSegmentator/scripts/usd_design/usd_shader_applier.py`:
- Around line 449-451: Summary: current code skips setting defaults when the
default value is explicitly None; change the check to test for the presence of
the "default" key instead of comparing to None. Replace the condition `if
data["customData"]["default"] is not None` with a key-existence test like `if
"default" in data["customData"]` so that inp.Set(data["customData"]["default"])
is called even when the default is None; keep the surrounding `if "customData"
in data` guard and use the existing inp.Set(...) call to apply the value.

---

Duplicate comments:
In `@models/CoronSegmentator/scripts/cardiac_segmentation/cardiac_seg.py`:
- Around line 120-121: The catch block in cardiac_seg.py that reads "except
Exception as e: raise e" is redundant and should be removed so exceptions
propagate naturally; locate the try/except surrounding the cardiac segmentation
logic (the block containing "except Exception as e: raise e") and either delete
the entire except clause or replace it with meaningful error handling or a
finally block for cleanup, ensuring you do not re-raise the exception in a way
that loses the original stack trace.

---

Nitpick comments:
In
`@models/CoronSegmentator/scripts/cardiac_segmentation/auto3dseg_segresnet_inference.py`:
- Around line 233-239: The current inline conditional that attempts to append
KeepLargestConnectedComponentd to post_transforms_list is hard to read; replace
it with a normal if statement: check if "whole-head" in model_file and then call
post_transforms_list.append(KeepLargestConnectedComponentd(keys="pred",
num_components=2)); leave post_transforms_list unchanged otherwise. This keeps
the same behavior but improves readability around the post_transforms_list and
KeepLargestConnectedComponentd usage.
- Line 138: The line building normalize_modes currently concatenates lists;
replace the concatenation with iterable unpacking: construct normalize_modes by
starting with main_normalize_mode and unpacking extra_modalities.values() into
the same list (i.e., use main_normalize_mode followed by
*extra_modalities.values()) so the variable normalize_modes is built via
unpacking rather than list addition; locate this change where normalize_modes,
main_normalize_mode, and extra_modalities are referenced in
auto3dseg_segresnet_inference.py.
- Around line 23-24: Remove the unused commented import line referencing
MetaKeys; specifically delete the commented line "# from monai.utils import
MetaKeys, convert_to_dst_type" so only the active import "from monai.utils
import convert_to_dst_type" remains (look for the import statements at the top
where convert_to_dst_type and MetaKeys are mentioned).

In `@models/CoronSegmentator/scripts/file_process/file_conversion.py`:
- Around line 97-101: The code creates a degenerate mesh when volume_data is all
zeros (dummy_vertices/dummy_faces used to build mesh_obj via trimesh.Trimesh),
which can break downstream USD conversion/rendering; update the empty-volume
handling in file_conversion.py by either raising a clear exception (e.g.,
ValueError or a custom EmptyVolumeError) when volume_data contains only zeros,
or if a placeholder mesh must be produced, replace the degenerate triangle with
a valid minimal non-degenerate geometry and add a concise comment explaining why
the dummy mesh is required and how downstream code (e.g., the USD conversion
path) must treat it; ensure the change references the volume_data check and the
creation of mesh_obj so reviewers can find the fix.

In `@models/CoronSegmentator/scripts/usd_design/shader_leather_red.py`:
- Around line 391-392: Remove the two commented lines that reference shader
creation in shader_leather_red.py (the commented bsdf assignment and
bsdf.CreateIdAttr call); specifically delete the lines commenting out use of
self._create_shader(Sdf.Path(self.base_path), "preview_Principled_BSDF") and the
subsequent CreateIdAttr('UsdPreviewSurface') so there is no leftover commented
shader code (symbols: bsdf, _create_shader, Sdf.Path, self.base_path,
"preview_Principled_BSDF", CreateIdAttr, 'UsdPreviewSurface').
- Around line 132-136: Remove the dead commented-out dictionary block that
defines image_texture (the lines starting with "# image_texture = { ... }");
delete those commented lines so the file no longer contains unused commented
code and ensure there are no other stray commented definitions of image_texture
or related unused variables (texture, mono_source, brightness, contrast,
translation, scaling, rotation, invert, texture_space, clip) left behind.

In `@models/CoronSegmentator/scripts/usd_design/usd_mesh_creator.py`:
- Line 125: Remove the dead commented code line containing "# meshes =
[self.load_mesh(file) for file in self.input_files]" from usd_mesh_creator.py;
locate the occurrence referencing self.load_mesh and self.input_files (inside
the USD mesh creation routine) and delete the commented-out list comprehension
so the file contains only active, relevant code.